package com.example.pro1.service.lian.oldService;


import com.example.pro1.entity.lian.oldPojo.*;
import com.example.pro1.mapper.lian.oldMapper.goodMapperOld;
import io.swagger.models.auth.In;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

/*商品信息维护*/
@Service
@Transactional
public class goodInfoService {
    @Autowired
    goodMapperOld goodMapperOld;

    /*商城*/

    /**/

    /*小程序主页推荐列表接口*/
    public List<recommendGoodsInfo> getRecommendGoods(Integer k){
        return goodMapperOld.getRecommendGoods(k);
    }

    /*获取轮播图接口*/
    public List<turnImages> getTurnImages(){
        return goodMapperOld.getTurnImages();
    }

    /*商品信息维护/goodsInfo*/
    public String upLoadImage(MultipartFile file){
        if(!file.isEmpty()){
            String uploadPath = "/www/wwwroot/img";
            // 如果目录不存在则创建
            File uploadDir = new File(uploadPath);
            if (!uploadDir.exists()) {
                uploadDir.mkdir();
            }
            String OriginalFilename = file.getOriginalFilename();//获取原文件名
            String suffixName = OriginalFilename.substring(OriginalFilename.lastIndexOf("."));//获取文件后缀名
            //重新随机生成名字
            String filename = UUID.randomUUID().toString() +suffixName;
            File localFile = new File(uploadPath+"/"+filename);
            String visitURL = "http://124.222.54.34/"+filename;
            try {
                file.transferTo(localFile); //把上传的文件保存至本地
                /**
                 * 这里应该把filename保存到数据库,供前端访问时使用
                 */
                System.out.println("保存成功");
//                String returnUrl = "http://124.222.54.34:80/"+filename;
//                String returnUrl = "http://localhost:80/"+filename;
                return visitURL;//上传成功，返回保存的文件地址
            }catch (IOException e){
                e.printStackTrace();
                System.out.println("上传失败");
                return "";
            }
        }else{
            System.out.println("文件为空");
            return "";
        }
    }

    /*查询商品信息*/
    /*获取商品的数量*/
    public Integer getGoodsNum(){
        return goodMapperOld.getGoodsNum();
    };

    public List<goodOld> getGoodsInfo(Map<String,Object> map){
        /*通过service方法来查询*/
        /*根据商品id查询其所对应的一级分类与二级分类的对应信息*/
        return goodMapperOld.getGoodsInfo(map);
    }

    /*查询商品详细信息*/
    public List<goodWithSort> getGoodWithSort(Map<String,Object> map){
//        if (map.containsKey("gId"))map.put("gId",Integer.parseInt((String) map.get("gId")));
//        if (map.containsKey("gssId"))map.put("gssId",Integer.parseInt((String) map.get("gssId")));
//        if (map.containsKey("gfsId"))map.put("gfsId",Integer.parseInt((String) map.get("gfsId")));
        if (map.containsKey("k") && map.containsKey("num")){
            map.put("k",Integer.parseInt((String) map.get("k")));
            map.put("num",Integer.parseInt((String) map.get("num")));
            map.put("kNum",(Integer)map.get("k")*(Integer)map.get("num"));
        }
        return goodMapperOld.getGoodWithSort(map);
    }

    /*推荐页面返回信息*/
    public List<goodWithSort> getGoodWithSortByKAndNum(Map<String,Object> map){
        /*先检查里面是否含有maxId和num字段*/
        if (map.containsKey("k")&&map.containsKey("num")){
            /*将这个字段转换为int*/
            map.put("k",Integer.parseInt((String) map.get("k")));
            map.put("num",Integer.parseInt((String) map.get("num")));
            map.put("kn",(Integer)((Integer)map.get("k")*(Integer)map.get("num")));
            return goodMapperOld.getGoodWithSortByKAndNum(map);
        }else {
            return null;
        }
    }

    /*返回一级分类和二级分类的连接信息*/
    public List<gfsWithGss> getGfsWithGss(Map<String,Object> map){
//        if (map.containsKey("gssId"))map.put("gssId",Integer.parseInt((String) map.get("gssId")));
//        if (map.containsKey("gfsId"))map.put("gfsId",Integer.parseInt((String) map.get("gfsId")));
        return goodMapperOld.getGfsWithGss(map);
    }

    /*商品添加*/
    public boolean addOneGood(Map<String,Object> map){
        /*需要先对map进行检测*/
        String[] strings = {"gId","gName","gNumber","gInPrice","gOutPrice","gImageSrc","gOutNum"};
        for (int i = 0; i < strings.length; i++) {
            if (!map.containsKey(strings[i]))
                map.put(strings[i],"");
        }
        /*同时检查有没有一级二级的商品类别id*/
        if (map.containsKey("gssId")){
            /*我们首先需要将gssId转换为Integer*/
            map.put("gssId",Integer.parseInt((String)map.get("gssId")));
            /*先插入相关商品*/
            /*根据已有gId插入到goodToGfs表和gssToGfs表中*/
            /*再根据GssToGfs插入gssId*/
            return goodMapperOld.insertOneGood(map)&& goodMapperOld.insertIdToGoodToGss(map);
            /**/
        }else {
            return false;
        }
    }

    /*商品修改*/
    public boolean updateGoodsInfo(Map<String,Object> map){
        return goodMapperOld.updateGoodByInfo(map);
    }

    /*根据商品Id修改商品信息*/
    public boolean updateGoodsById(Map<String,Object> map){
        /*需要先检测是否含有gId*/
        if (map.containsKey("gId")&&map.size()>1){
            /*将gId转换为整形*/
            map.put("gId",Integer.parseInt((String)map.get("gId")));
            return goodMapperOld.updateGoodById(map);
        }else {
            return false;
        }

    }

    /*商品删除*/
    public boolean deleteOneGoodById(Map<String,Object> map){
        /*先检查是否有gid,否则就返回*/
        if (map.containsKey("gId")&&map.containsKey("gssId")){
            return goodMapperOld.deleteGoodToGss(map)&& goodMapperOld.deleteGoodByInfoById(map);
        }else {
            return false;
        }
    }

    /*获取一级分类*/
    public List<goodFirstSort> getGoodFirstSort(Map<String,Object> map){
        return goodMapperOld.getGoodFirstSort(map);
    }

    /*获取二级分类*/
    public List<goodSecondSort> getGoodSecondSort(Map<String,Object> map){
        return goodMapperOld.getGoodSecondSort(map);
    }

    /*添加新的一级分类*/
    public boolean addFirstSort(Map<String,Object> map){
        /*首先要检擦一个对应的接口信息*/
        String[] secondSortFilds = {"gfsId","gfsName","gfsImageSrc"};
        for (int i = 0; i < secondSortFilds.length; i++) {
            if (!map.containsKey(secondSortFilds[i])){
                map.put(secondSortFilds[i],null);;
            }
        }
        /*添加新的一级分类不需要其它信息*/
        return goodMapperOld.insertGfs(map);
    }

    /*删除一级分类信息*/
    public boolean deleteFirstSort(Map<String,Object> map){
        /*先查看是否有gfsId字段*/
        if (!map.containsKey("gfsId"))
            return false;
        /*需要先去查看是否有对应的二级分类信息,需要转入gfsId*/
        List<gssToGfs> gssToGfs = goodMapperOld.getGssToGfs(map);
        if (gssToGfs.size()==0){
            /*没有相应字段，可以删除*/
            return goodMapperOld.deleteGoodFirstSort(map);
        }else {
            return false;
        }
    }

    /*添加新的二级分类*/
    public boolean addSecondSort(Map<String,Object> map){
        if (!map.containsKey("gfsId"))
            return false;
        /*首先要检擦一个对应的接口信息*/
        String[] secondSortFilds = {"gssId","gssName","gssImageSrc"};
        for (int i = 0; i < secondSortFilds.length; i++) {
            if (!map.containsKey(secondSortFilds[i])){
                map.put(secondSortFilds[i],null);;
            }
        }
        /*添加新的二级分类需要指定所属的一级分类*/
        /*将二级分类与一级分类关联起来*/
        return goodMapperOld.insertGss(map)&& goodMapperOld.insertIdToGssToGfs(map);
    }

    /*删除二级分类信息*/
    public boolean deleteSecondSort(Map<String,Object> map){
        /*先查看是否有gssId字段*/
        if (!map.containsKey("gssId"))
            return false;
        /*需要先去查看是否有对应的商品,需要转入gssId*/
        List<goodToGfs> goodToGfs = goodMapperOld.getGoodToGss(map);
        if (goodToGfs.size()==0){
            /*没有相应字段，可以删除*/
            /*我们需要删除和第一类商品信息对应的连接表*/
            return goodMapperOld.deleteGfsToGss(map)&& goodMapperOld.deleteGoodSecondSort(map) ;
        }else {
            return false;
        }
    }

    /*返回所有分类页面的信息*/
    public List<goodFirstSort> returnSortPageInfo() {
        /*查询所有已知的一级分类信息*/
        List<goodFirstSort> goodFirstSortList = goodMapperOld.getGoodFirstSort(new HashMap<>());
        System.out.println(goodFirstSortList);
        /*根据每个一级分类的id查询一级分类和二级分类的关系*/
        /*遍历所有的一级分类信息集合*/
        for (goodFirstSort goodFirstSort : goodFirstSortList) {
            /*每一个一级分类对应多个二级分类*/
            /*查询这个一级分类对应的二级分类的列表*/
            List<Integer> gssIds = goodMapperOld.getGssIdByGfsId(goodFirstSort.getGfsId());
            /*如果对应的gssIds的数量为0也就没有继续的必要了*/
            if (gssIds.size()>0){
                /*再查询出对应的二级分类的对象的所有的信息,以list集合的形式*/
                List<goodSecondSort> goodSecondSortList = goodMapperOld.getGoodSecondSortByIds(gssIds);
                /*将这个对象添加到一级分类对象中*/
                goodFirstSort.setGfsGoodSecondSort(goodSecondSortList);
                /*遍历所有的二级对象*/
                for (goodSecondSort goodSecondSort : goodSecondSortList) {
                    /*每个二级分类对应多个商品,*/
                    /*查询这个二级分类对应的商品的列表*/
                    List<Integer> gIds = goodMapperOld.getGidByGssId(goodSecondSort.getGssId());
                    if (gIds.size()>0){
                        /*再查询出对应的所有的商品的信息，以list集合的形式*/
                        List<goodOld> goodOldList = goodMapperOld.getGoodsByIds(gIds);
                        /*将这个对象插入二级商品信息中*/
                        goodSecondSort.setGoodOlds(goodOldList);
                    }else {
                        goodSecondSort.setGoodOlds(null);
                    }
                }
            }else {
                /*将null添加到一级分类对象中*/
                goodFirstSort.setGfsGoodSecondSort(null);
            }
        }
        return goodFirstSortList;
    }

    /*添加购物车信息*/
    public boolean addCartInfo(Map<String,Object> map){
        if (!(map.containsKey("gId")&&map.containsKey("cId"))){
            return false;
        }else {
            /*对gid与cid进行Integer的转换*/
            map.put("gId",Integer.parseInt((String) map.get("gId")));
            map.put("cId",Integer.parseInt((String) map.get("cId")));
            if (map.containsKey("num")){
                map.put("num",1);
            }
            return goodMapperOld.addShopCart(map);
        }
    }

    /*查询购物车信息*/
    /*必须有cId*/
    public List<cartInfo> selectCartInfo(Map<String,Object> map){
        if (!(map.containsKey("cId"))){
            return null;
        }else {
            /*对gid与cid进行Integer的转换*/
            map.put("cId",Integer.parseInt((String) map.get("cId")));
            return goodMapperOld.queryCart(map);
        }
    }

    /*添加收藏信息*/
    public boolean addCollection(Map<String,Object> map){
        if (!(map.containsKey("gId")&&map.containsKey("cId"))){
            return false;
        }else {
            /*对gid与cid进行Integer的转换*/
            map.put("gId",Integer.parseInt((String) map.get("gId")));
            map.put("cId",Integer.parseInt((String) map.get("cId")));
            if (map.containsKey("num")){
                map.put("num",1);
            }
            return goodMapperOld.addCollections(map);
        }
    }

    /*查询收藏信息*/
    public List<goodOld> queryCollection(Map<String,Object> map){
        if (!(map.containsKey("cId"))){
            return null;
        }else {
            return goodMapperOld.queryCollection(map);
        }
    }


    /*返回表一的信息*/
    public List<t1> getT1Info(){
        return goodMapperOld.getT1Info();
    }

    /*返回表二的信息*/
    public List<t2> getT2Info(){
        return goodMapperOld.getT2Info();
    }

}
